home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / dev / c / curses_2_00.readme < prev    next >
Text File  |  1992-08-14  |  23KB  |  805 lines
  1. Short: Amiga Curses Package V2.00
  2.  
  3.  
  4.             AMIGA CURSES PACKAGE V2.00
  5.             ==========================
  6.  
  7. Author : Simon John Raybould    (sie@fulcrum.co.uk)
  8. Date   : 20th June 1992
  9.  
  10.  
  11. Version
  12. =======
  13.  
  14. $Id: curses.doc,v 1.3 92/06/29 22:33:08 sie Exp $
  15.  
  16.  
  17. Modification History
  18. ====================
  19.  
  20. $Log:    curses.doc,v $
  21. Revision 1.3  92/06/29  22:33:08  sie
  22. Added some more function descriptions.
  23.  
  24. Revision 1.2  92/06/23  22:38:14  sie
  25. Documentation for amiga curses library.
  26.  
  27.  
  28.  
  29. Description
  30. ===========
  31.  
  32. Version 2.00 and above now support ANSI sequences to allow curses
  33. applications to be executes through the serial port to a terminal or
  34. over a modem to a terminal or terminal package such as "Term20" or
  35. "jrcomm". To enable this, simply set the environment variable
  36. "cursestype" to "ansi" before running the program. If this variable is
  37. not set, curses will open a custom screen.
  38.  
  39. The default number of colours for the custom screen is now 2 (black
  40. and white). To enable 8 colours, call start_color() before initscr().
  41. has_colors() will return TRUE if start_color() has been called else it
  42. will return FALSE.
  43.  
  44.  
  45.  
  46.  
  47. Short descriptions of functions provided
  48. ========================================
  49.  
  50. int initscr(void)
  51.  
  52.     This must be called before any window can be created or
  53.     manipulated. It creates "stdscr" and "curscr". curscr is a copy of
  54.     what curses thinks is currently on the display. Calling
  55.     wrefresh(curscr) will redraw the entire screen and is useful for
  56.     noisy modem lines. This is usually called when the user types ^L
  57.     or sometimes ^R in older programs.
  58.  
  59.     Return value
  60.     ============
  61.     On Success, OK is returned.
  62.     On error, ERR is returned
  63.  
  64.  
  65. int endwin(void)
  66.  
  67.     This should be called before exiting a curses program.
  68.     It frees all memory used and dismantles all structures.
  69.     It closes the custom screen and window used if curses is used in
  70.     non-ANSI mode.
  71.  
  72.     Return value
  73.     ============
  74.     On Success, OK is returned.
  75.     On error, ERR is returned
  76.  
  77.  
  78. int beep(void)
  79.  
  80.     Produces an audible beep from the speaker. This beep is similar in pitch
  81.     and duration to the beep from a terminal when a BEL (^G) character is
  82.     received. If curses is running in ANSI mode, a BEL character will
  83.     be sent to the terminal.
  84.  
  85.     Return value
  86.     ============
  87.     On Success, OK is returned.
  88.     On error, ERR is returned
  89.  
  90.  
  91. int flash(void)
  92.  
  93.     Flashes the display by complementing the background colour. With the
  94.     default black background, this will flash the screen yellow. If
  95.     curses is being used in ANSI mode, a BEL character will be sent to
  96.     the terminal.
  97.  
  98.     Return value
  99.     ============
  100.     On Success, OK is returned.
  101.     On error, ERR is returned
  102.  
  103.  
  104. int baudrate(void)
  105.  
  106.     Returns current baudrate. On the Amiga, it just returns 19200. It is
  107.     used to decide how much to refresh over slow serial lines such as
  108.     modems.
  109.  
  110.     Return value
  111.     ============
  112.     19200 is returned.
  113.  
  114.  
  115. int box(WINDOW *win, char vert, char hor)
  116.  
  117.     Draws a box around the INSIDE edge of the window.
  118.     win   - pointer returned from newwin or subwin, or stdscr even.
  119.     vert  - character to use for the vertical.
  120.     hor   - character to use for the horizontal.
  121.  
  122.     Either of the characters may be zero. In this case, the defaults of
  123.     "|" and "-" will be used for vertical and horizontal respectively.
  124.  
  125.     NOTE
  126.     ----
  127.     The box drawn is INSIDE the window. Therefore any of the clear routines
  128.     will effect the box if carried out on its window. The normal thing
  129.     to do is open two windows, one for the box two columns wider and
  130.     two lines higher than the window for the text. Then use the inner
  131.     window for the text. This way the box is only drawn once.
  132.  
  133.     Return value
  134.     ============
  135.     On Success, OK is returned.
  136.     On error, ERR is returned
  137.  
  138.  
  139. int cbreak(void)
  140. int nocbreak(void)
  141.  
  142.     cbreak() puts the terminal into CBREAK mode, making characters typed
  143.     available immediately.
  144.  
  145.     nocbreak() sets NOCBREAK mode and characters are not available until
  146.     carriage return is pressed.
  147.  
  148.     The default is NOCBREAK mode, so most programs call cbreak() before
  149.     doing any reads on the keyboard for interactive use.
  150.  
  151.     Return value
  152.     ============
  153.     On Success, OK is returned.
  154.     On error, ERR is returned
  155.  
  156.  
  157. int crmode(void)
  158. int nocrmode(void)
  159.  
  160.     As cbreak() and nocbreak() as shown above.
  161.  
  162.     Return value
  163.     ============
  164.     On Success, OK is returned.
  165.     On error, ERR is returned
  166.  
  167.  
  168. int clearok(WINDOW *win, int flag)
  169.  
  170.     If flag is TRUE then it is OK to clear the window on the next refresh.
  171.  
  172.     Return value
  173.     ============
  174.     On Success, OK is returned.
  175.     On error, ERR is returned
  176.  
  177.  
  178. int leaveok(WINDOW *win, int flag)
  179.  
  180.     If flag is TRUE then curses doesn"t care where it leaves the
  181.     cursor. If possible, the cursor will not be displayed.
  182.     The default is FALSE and the cursor is displayed correctly.
  183.  
  184.     Return value
  185.     ============
  186.     On Success, OK is returned.
  187.     On error, ERR is returned
  188.  
  189.  
  190. WINDOW *subwin(WINDOW *orig, int lines, int cols, int beg_line, int beg_col)
  191.  
  192.     Creates a new window within another window. The original window has
  193.     its pointer passed as "orig".
  194.     The new window will be at line "beg_line" and column "beg_col" of the
  195.     window pointed to by "orig". It will be of size "lines" lines of "cols"
  196.     columns.
  197.  
  198.     A sub-window is part of its surrounding window. When the surrounding
  199.     window is refreshed, the sub-window is refreshed as well.
  200.  
  201.     Return value
  202.     ============
  203.     On success, a pointer to a new window is returned.
  204.     On failure, a NULL pointer is returned.
  205.  
  206.  
  207. WINDOW *newwin(int lines, int cols, int beg_line, int beg_col)
  208.  
  209.     Creates a new window at line "beg_line" and column "beg_col",
  210.     "lines" high by "cols" wide.
  211.  
  212.     The new window has its own data structures and does not affect any
  213.     data in other windows. It is only refreshed by a call like
  214.     wrefresh(win) where "win" was returned by this function.
  215.  
  216.     Return value
  217.     ============
  218.     On success, a pointer to a new window is returned.
  219.     On failure, a NULL pointer is returned.
  220.  
  221.  
  222. int delwin(WINDOW *win)
  223.  
  224.     Deletes a window and frees the associated memory. This should be done if
  225.     the window is no longer used.
  226.  
  227.     It is not necessary to free all windows, endwin() will free all windows
  228.     still allocated before returning.
  229.  
  230.     Return value
  231.     ============
  232.     On Success, OK is returned.
  233.     On error, ERR is returned
  234.  
  235.  
  236. int mvwin(WINDOW *win, int new_line, int new_col)
  237.  
  238.     Moves a window to a new position on the screen. This position is relative
  239.     to the top left of the screen and NOT to the start of any surrounding
  240.     window in the case of sub-windows.
  241.  
  242.     Return value
  243.     ============
  244.     On Success, OK is returned.
  245.     On error, ERR is returned
  246.  
  247.  
  248. int nl(void)
  249. int nonl(void)
  250.  
  251.     nl() - Causes newline to newline/carriage return mapping on output and
  252.     return to newline mapping on input.
  253.  
  254.     nonl() - disables this.
  255.     The DEFAULT is that mapping is done (nl).
  256.  
  257.     Return value
  258.     ============
  259.     On Success, OK is returned.
  260.     On error, ERR is returned
  261.  
  262.  
  263. int echo(void)
  264. int noecho(void)
  265.  
  266.     echo() causes characters read from the keyboard to be echoed to the
  267.     display. noecho() prevents the echo, this is useful when reading
  268.     keys that you don"t want echoed to the screen.
  269.     The DEFAULT is that echoing is performed (echo).
  270.  
  271.     Return value
  272.     ============
  273.     On Success, OK is returned.
  274.     On error, ERR is returned
  275.  
  276.  
  277. int nodelay(WINDOW *win, int flag)
  278.  
  279.     nodelay() sets nodelay mode if "flag" is TRUE.  When in nodelay mode,
  280.     getch() will return ERR if there is no input pending.  The DEFAULT is
  281.     nodelay not set and getch() will block, waiting for at least one char
  282.     in CBREAK mode or a line followed by carriage return in non CBREAK
  283.     mode.
  284.  
  285.     Return value
  286.     ============
  287.     On Success, OK is returned.
  288.     On error, ERR is returned
  289.  
  290.  
  291. int has_colors(void)
  292. int start_color(void)
  293. int init_color(int n, int r, int g, int b) 
  294.  
  295.     has_colors() is to check if colours are available on this terminal.
  296.     On the Amiga, it will return TRUE if start_color() has been called
  297.     else it will return FALSE.
  298.  
  299.     start_colour() is to tell the terminal that you wish to use colour. In
  300.     Amiga curses, this MUST be called before initscr() or it will have no
  301.     effect because initscr() sets up the screen and needs to know how many
  302.     colours you want.
  303.  
  304.     init_color() will alter the Red, Green and Blue content of colour n.
  305.     r, g and b are in the range 1 to 1000. The colour number "n" is in the
  306.     range 0 to 15 and it should be noted that colour 0 is the background
  307.     colour. Initially the foreground is set to colour 1 but can be changed
  308.     with the attron() or attrset() function to any of the colours 1 to 15,
  309.     0 is not allowed as this is the background. If 0 is selected, the
  310.     foreground colour will be set to 1.
  311.  
  312.     Return value
  313.     ============
  314.     On Success, OK is returned.
  315.     On error, ERR is returned
  316.  
  317.  
  318. int keypad(WINDOW *win, int flag)
  319.  
  320.     If "flag" is TRUE then the ANSI sequences for the function keys and
  321.     the cursor keys will be converted to the tokens KEY_UP, KEY_HELP,
  322.     e.t.c.  The DEFAULT is that the ANSI sequences will returned.  So to
  323.     cause special keys to be returned as tokens in the standard screen,
  324.     add the following line:
  325.  
  326.         keypad(stdscr, TRUE);
  327.  
  328.     Return value
  329.     ============
  330.     On Success, OK is returned.
  331.     On error, ERR is returned
  332.  
  333.  
  334. int printw(char *fmt, ...)
  335. int wprintw(WINDOW *win, char *fmt, ...)
  336. int mvprintw(int line, int col, char *fmt, ...)
  337. int mvwprintw(WINDOW *win, int line, int col, char *fmt, ...)
  338.  
  339.     Produce formatted output similar to printf(3).
  340.     printw() - prints at the current position in stdscr.
  341.     wprintw() - prints at the current position in win.
  342.     mvprintw() - prints at line "line" column "col" in stdscr.
  343.     mvwprintw() - prints at line "line" column "col" in "win".
  344.  
  345.     Return value
  346.     ============
  347.     On Success, number of formats successfully replaced is returned.
  348.     On error, -1 is returned.
  349.  
  350.  
  351. scanw(char *fmt, ...)
  352. wscanw(WINDOW *win, char *fmt, ...)
  353. mvscanw(int line, int col, char *fmt, ...)
  354. mvwscanw(WINDOW *win, int line, int col, char *fmt, ...)
  355.  
  356.     Produce formatted input similar to scanf(3).
  357.     scanw() - scans at the current position in stdscr.
  358.     wscanw() - scans at the current position in win.
  359.     mvscanw() - scans at line "line" column "col" in stdscr.
  360.     mvwscanw() - scans at line "line" column "col" in "win".
  361.  
  362.     Return value
  363.     ============
  364.     On Success, number of formats successfully replaced is returned.
  365.     On error, -1 is returned.
  366.  
  367.  
  368. int scrollok(WINDOW *win, int flag)
  369.  
  370.     When flag is true, curses will automatically scroll the window up one
  371.     line when output goes off the bottom of "win".
  372.     E.g.
  373.             scrollok(stdscr, TRUE);
  374.     
  375.     "stdscr" will then be automatically scrolled up one line when output goes
  376.     off bottom.
  377.     The DEFAULT is that the window will NOT be scrolled, the bottom line
  378.     will be used over and over again without scrolling.
  379.  
  380.     Return value
  381.     ============
  382.     On Success, OK is returned.
  383.     On error, ERR is returned
  384.  
  385.  
  386. int scroll(WINDOW *win)
  387.  
  388.     The window "win" is scrolled up one line.
  389.  
  390.     Return value
  391.     ============
  392.     On Success, OK is returned.
  393.     On error, ERR is returned
  394.  
  395.  
  396. int setscrreg(int top, int bottom)
  397. int wsetscrreg(WINDOW *win, int top, int bottom)
  398.  
  399.     Sets the scrolling region from line "top" to line "bottom" inclusive.
  400.     Only the region between these two lines is scrolled when scroll() is
  401.     called or when output moves off the end of line "bottom", the region
  402.     is scrolled up one line (if scrollok() has been called).
  403.  
  404.     Return value
  405.     ============
  406.     On Success, OK is returned.
  407.     On error, ERR is returned
  408.  
  409.  
  410. int touchwin(WINDOW *win)
  411.  
  412.     Will force the window to be completely refreshed on the next call to
  413.     refresh() by dumping all optimization information. This can be useful if
  414.     the state of the screen is unknown or if a window was obscured by
  415.     another window which was not a subwindow of the one it covered. Then
  416.     you may need to touchwin() the window that was covered and refresh it.
  417.  
  418.     If you have several windows and wish to redraw the entire display,
  419.     such as when ^L is pressed in many applications, you could touchwin
  420.     all of your windows, clear the screen and refresh each one in turn.
  421.     The recommended way to do this however is to simply wrefresh(curscr).
  422.  
  423.     Return value
  424.     ============
  425.     On Success, OK is returned.
  426.     On error, ERR is returned
  427.  
  428.  
  429. int addch(char c)
  430. int waddch(WINDOW *win, char c)
  431. int mvaddch(int int line, int col, char c)
  432. int mvwaddch(WINDOW *win, int line, int col, char c)
  433.  
  434.     addch(c) - Prints character "c" at current screen position in "stdscr".
  435.  
  436.     waddch(win, c) - Prints character "c" at current screen position in "win".
  437.  
  438.     mvaddch(line, col, c) - Prints character "c" at line "line" column "col" in
  439.             "stdscr".
  440.  
  441.     mvwaddch(win, line, col, c) - Prints character "c" at line "line" column
  442.             "col" in win.
  443.  
  444.     Return value
  445.     ============
  446.     On Success, OK is returned.
  447.     On error, ERR is returned
  448.  
  449.  
  450. int addstr(char *str)
  451. int waddstr(WINDOW *win, char *str)
  452. int mvaddstr(int line, int col, char *str)
  453. int mvwaddstr(WINDOW *win, int line, int col, char *str)
  454.  
  455.     addstr(str) - Prints string "str" at the current screen position in "stdscr".
  456.  
  457.     waddstr(win, str) - Prints string "str" at current screen position in "win".
  458.  
  459.     mvaddstr(line, col, str) - Prints string "str" at line "line" column "col"
  460.             in "stdscr".
  461.  
  462.     mvwaddstr(win, line, col, str) - Prints string "str" at line "line"
  463.               column "col" in window "win".
  464.  
  465.     Return value
  466.     ============
  467.     On Success, OK is returned.
  468.     On error, ERR is returned
  469.  
  470.  
  471. int attrset(UBYTE attrs)
  472. int wattrset(WINDOW *win, UBYTE attrs)
  473.  
  474.     These routines set the attributes for "stdscr" or the specified window
  475.     (in the case of wattrset()) to the value specified in "attrs". This is
  476.     usually used to get the attributes to a known state before using
  477.     attron() and attroff() to add and remove extra attributes
  478.     respectively. The danger is that all previous attributes are lost and
  479.     replaced by the new ones. Consequently they are not really necessary.
  480.  
  481.     See attron() and attroff().
  482.  
  483.     Return value
  484.     ============
  485.     On Success, OK is returned.
  486.     On error, ERR is returned
  487.  
  488.  
  489. int attron(UBYTE attrs)
  490. int wattron(WINDOW *win, UBYTE attrs)
  491.  
  492.     These routines add the attributes specified in "attrs" to those
  493.     already set for "stdscr" or the window specified (in the case of
  494.     wattron()). Any previous attributes that are not directly affected by
  495.     the changes will be left as they were. This is the preferred way to
  496.     set and unset attributes as it has no effect on other attributes.
  497.  
  498.     Return value
  499.     ============
  500.     On Success, OK is returned.
  501.     On error, ERR is returned
  502.  
  503.  
  504. int attroff(UBYTE attrs)
  505. int wattroff(WINDOW *win, UBYTE attrs)
  506.  
  507.     These routines remove the attributes specified in attrs from those set
  508.     for stdscr or the window specified in the case of wattroff().  Any
  509.     previous attributes that are not directly affected by the changes will
  510.     be left as they were.  This is the preferred method of resetting
  511.     attributes rather than calling attrset.
  512.  
  513.     Example:
  514.  
  515.         attron(A_REVERSE)
  516.         addstr("This is in inverse");
  517.         attroff(A_REVERSE);
  518.         refresh();
  519.  
  520.     Return value
  521.     ============
  522.     On Success, OK is returned.
  523.     On error, ERR is returned
  524.  
  525.  
  526. int standout(void)
  527. int wstandout(WINDOW *win)
  528. int standend(void)
  529. int wstandend(WINDOW *win)
  530.  
  531.     These routines set and reset inverse video mode.
  532.  
  533.     Example
  534.     =======
  535.  
  536.     standout();
  537.     addstr("This is inverse video");
  538.     standend();
  539.     addstr("This is normal video");
  540.     refresh();
  541.  
  542.     Return value
  543.     ============
  544.     On Success, OK is returned.
  545.     On error, ERR is returned
  546.  
  547.  
  548. int erase(void)
  549. int werase(WINDOW *win)
  550.  
  551.     These routines will empty the screen buffer and will cause the screen
  552.     to be cleared on the next call to refresh().
  553.  
  554.     Return value
  555.     ============
  556.     On Success, OK is returned.
  557.     On error, ERR is returned
  558.  
  559.  
  560. int clear(void)
  561. int wclear(WINDOW *win)
  562.  
  563.     These routines will empty the screen buffer and will cause the screen
  564.     to be cleared on the next call to refresh(). Similar to erase() except
  565.     that these will call clearok() as well. If possible, a clear sequence
  566.     will be sent to the screen whereas erase() just fills the buffer with
  567.     spaces.
  568.  
  569.     Return value
  570.     ============
  571.     On Success, OK is returned.
  572.     On error, ERR is returned
  573.  
  574.  
  575. int clrtobot(void)
  576. int wclrtobot(WINDOW *win)
  577.  
  578.     On the next call to refresh(), the window will be cleared from the
  579.     current position to bottom righthand corner.
  580.  
  581.     Return value
  582.     ============
  583.     On Success, OK is returned.
  584.     On error, ERR is returned
  585.  
  586.  
  587. int clrtoeol(void)
  588. int wclrtoeol(win)
  589.  
  590.     On the next call to refresh(), the window will be cleared from the
  591.     current position to the end of the line.
  592.  
  593.     Return value
  594.     ============
  595.     On Success, OK is returned.
  596.     On error, ERR is returned
  597.  
  598.  
  599. int delch(void)
  600. int wdelch(WINDOW *win)
  601. int mvdelch(int line, int col)
  602. int mvwdelch(WINDOW *win, int line, int col)
  603.  
  604.     These routines delete the character at the current position, the rest
  605.     of the line to the right of this character is slid along to the left
  606.     to fill the gap. This can be very useful in editors and the like.
  607.  
  608.     Return value
  609.     ============
  610.     On Success, OK is returned.
  611.     On error, ERR is returned
  612.  
  613.  
  614. int getch(void)
  615. int wgetch(WINDOW *win)
  616. int mvgetch(int line, int col)
  617. int mvwgetch(WINDOW *win, int line, int col)
  618.  
  619.     These routines return the next character from the keyboard. If
  620.     cbreak() has been called then they return as soon as there is a
  621.     character to read else they wait for a <CR> before returning. If
  622.     nodelay() has been called then they will return a character if there
  623.     is one or ERR if not.
  624.  
  625.     Return value
  626.     ============
  627.     On Success, the character read is returned.
  628.     On error, ERR is returned
  629.  
  630.  
  631. int getstr(void)
  632. int wgetstr(WINDOW *win)
  633. int mvgetstr(int line, int col)
  634. int mvwgetstr(WINDOW *win, int line, int col)
  635.  
  636.     These routines should be used to read a string in from the keyboard.
  637.     Delete is processed for you.
  638.  
  639.     Return value
  640.     ============
  641.     On Success, OK is returned.
  642.     On error, ERR is returned
  643.  
  644.  
  645. int inch(void)
  646. int winch(WINDOW *win)
  647. int mvinch(int line, int col)
  648. int mvwinch(WINDOW *win, int line, int col)
  649.  
  650.     These routines return the character at the current position in the
  651.     window or stdscr if the window is not required.
  652.     The routines that take a line and column move the cursor to that
  653.     position in the window and then return the char at that position.
  654.  
  655.     Return value
  656.     ============
  657.     On Success, OK is returned.
  658.     On error, ERR is returned
  659.  
  660.  
  661. int insch(void)
  662. int winsch(WINDOW *win)
  663. int mvinsch(int line, int col)
  664. int mvwinsch(WINDOW *win, int line, int col)
  665.  
  666.     These routines insert a character at the current window position, or at
  667.     the specified position in the "mv" cases. The remainder of the line is
  668.     shifted along to the right to make room. The character at the far right
  669.     is lost.
  670.  
  671.     Return value
  672.     ============
  673.     On Success, OK is returned.
  674.     On error, ERR is returned
  675.  
  676.  
  677. int insertln(void)
  678. int winsterln(WINDOW *win)
  679.  
  680.     These routines insert one line at the current window position.
  681.     All of the lines below are shifted down and the bottom line is lost.
  682.  
  683.     Return value
  684.     ============
  685.     On Success, OK is returned.
  686.     On error, ERR is returned
  687.  
  688.  
  689. int deleteln(void)
  690. int wdeleteln(WINDOW *win)
  691.  
  692.     These routines delete one line at the current window position.
  693.     All of the lines below are shifted up into the space and the bottom line
  694.     is left blank.
  695.  
  696.     Return value
  697.     ============
  698.     On Success, OK is returned.
  699.     On error, ERR is returned
  700.  
  701.  
  702. int move(int line, int col)
  703. int wmove(WINDOW *win, int line, int col)
  704.  
  705.     These routines set the current coordinates to "line" and "col". The
  706.     next text added to this window will then go at this position.
  707.  
  708.     Return value
  709.     ============
  710.     On Success, OK is returned.
  711.     On error, ERR is returned
  712.  
  713.  
  714. int refresh(void)
  715. int wrefresh(WINDOW *win)
  716.  
  717.     refresh() will cause all outstanding characters for stdscr to be sent.
  718.     wrefresh() will do the same a refresh but on the window specified.
  719.  
  720.     Return value
  721.     ============
  722.     On Success, OK is returned.
  723.     On error, ERR is returned
  724.  
  725.  
  726. int wnoutrefresh(WINDOW *win)
  727. int doupdate(void)
  728.  
  729.     Will cause "win" to be refreshed when doupdate() is next called.
  730.     You can then wnoutrefresh() several windows and make one call to
  731.     doupdate() to do all the updates at once.
  732.  
  733.     Return value
  734.     ============
  735.     On Success, OK is returned.
  736.     On error, ERR is returned
  737.  
  738.  
  739. int fixterm(void)
  740.  
  741.     This function does nothing on the Amiga, it is provided to allow
  742.     programs that use it to link without trouble.
  743.  
  744.     Return value
  745.     ============
  746.     OK is returned.
  747.  
  748.  
  749. int flushinp(void)
  750.  
  751.     This function empties the keyboard buffer. It will trash all
  752.     characters that have been buffered up.
  753.  
  754.     Return value
  755.     ============
  756.     OK is returned.
  757.  
  758.  
  759. int idlok(WINDOW *WinPtr, int flag)
  760.  
  761.     This fuction enables hardware insert & delete line. This does not
  762.     currently have any effect.
  763.  
  764.     Return value
  765.     ============
  766.     OK is returned.
  767.  
  768.  
  769. int saveterm(void)
  770. int resetterm(void)
  771.  
  772.     saveterm() saves the current terminal settings and resetterm() resets
  773.     the terminal to the state it was in when the last save was done. On
  774.     the Amiga, they have no effect.
  775.  
  776.     Return value
  777.     ============
  778.     OK is returned.
  779.  
  780.  
  781. int savetty(void)
  782. int resetty(void)
  783.  
  784.     savetty() saves the current terminal settings and resettty() resets
  785.     the terminal to the state it was in when the last save was done. On
  786.     the Amiga, they have no effect.
  787.  
  788.     Return value
  789.     ============
  790.     OK is returned.
  791.  
  792.  
  793. int mvcur(int oldline, int oldcol, int newline, int newcol)
  794.  
  795.     This will move the cursor to the position specified by "newline" and
  796.     "newcol". The move is immediate and so refresh() does not need to be
  797.     called, in fact a call to refresh() will cause the cursor to be moved
  798.     after the last char printed during that refresh.
  799.     oldline and oldcol are currently ignored.
  800.  
  801.     Return value
  802.     ============
  803.     On Success, OK is returned.
  804.     On error, ERR is returned
  805.